var express = require("express");
var router = express.Router();
const analysisService = require("../service/analysisService");
const snapService = require('../service/snapService');
const typesService = require('../service/typesService');

/**
 * @swagger
 * /analysis/allshops:
 *    get:
 *      tags:
 *      - analysis
 *      summary: 获取不同类型商品的物品总数量
 *      parameters:
 *      - name: type
 *        in: query
 *        description: 商品类型
 *        required: false
 *      - name: valueNum
 *        in: query
 *        description: 该类型商品总数量
 *        required: false
 *      responses:
 *        200:
 *          description: 操作成功
 *        401:
 *          description: 权限不足
 * */
// 1.查找不同类型的商品所有数量
router.get('/allshops', async (req, res) => {
    // 拿到所有的商品类型
    let arrType = await typesService.findAll();
    let typeArr = [];
    // arrType是异步获取
    if (arrType) {
        // 存所有类型
        typeArr = arrType.map(item => {
            return {
                type: item.typeName,
                value: 0
            }
        });
        // 拿到所有的商品数据
        let arrOld = await analysisService.findAllshops();
        // 查询不同内型商品数量并累加
        if (arrOld) {
            for (let i = 0; i < arrOld.length; i++) {
                if (arrOld[i].types) {
                    let data = await typesService.findTypeById(arrOld[i].types);
                    // 把不同类型的商品数量进行累加
                    if (data.typeName) {
                        for (let j = 0; j < typeArr.length; j++) {
                            if (data.typeName === typeArr[j]['type']) {
                                typeArr[j]['value'] += parseInt(arrOld[i].total);
                            }
                        }
                    }
                }
            }
        }
        // 返回数据
        res.send({
            data: typeArr
        });
    }

});
/**
 * @swagger
 * /analysis/allorder:
 *    get:
 *      tags:
 *      - analysis
 *      summary: 获取不同类型商品的物品总销售额
 *      parameters:
 *      - name: type
 *        in: query
 *        description: 商品类型
 *        required: false
 *      - name: valueSale
 *        in: query
 *        description: 该类型商品总销售量
 *        required: false
 *      responses:
 *        200:
 *          description: 操作成功
 *        401:
 *          description: 权限不足
 * */
// 2.查询所有的订单，统计不同类型的商品销售总数   snaps
router.get('/allorder', async function (req, res, next) {
    // 查询所有的商品类型
    let arrType = await typesService.findAll();
    // 存所有的商品类型
    let typeArr = [];
    // 存通过订单id查询到的具体某个商品的快照信息
    let commityArr = [];
    // arrType是异步获取
    if (arrType) {
        // 存所有类型
        typeArr = arrType.map(item => {
            return {
                type: item.typeName,
                sales: 0
            }
        });
        // 查询所有的订单集合
        let arrOrder = await analysisService.findAllOrder();
        if (arrOrder) {
            // 查询不同内型商品数量并累加
            for (let i = 0; i < arrOrder.length; i++) {
                // 通过订单id在商品快照集合表中查询订单相关的商品信息
                commityArr = await snapService.findByOrderId(arrOrder[i]._id);
                if (commityArr.length > 0) {
                    // 一个订单有多个商品
                    for (let m = 0; m < commityArr.length; m++) {
                        if (commityArr[m].types && commityArr[m].sale && commityArr[m].price) {
                            // 把不同类型的商品数量进行累加
                            for (let j = 0; j < typeArr.length; j++) {
                                if (commityArr[m].types === typeArr[j]['type']) {
                                    typeArr[j]['sales'] += parseInt(commityArr[m].sale) * parseInt(commityArr[m].price);
                                }
                            }
                        }
                    }
                }
            }
        }
        // 返回数据
        res.send({
            data: typeArr
        });
    }

});
/**
 * @swagger
 * /analysis/allorderByTime:
 *    get:
 *      tags:
 *      - analysis
 *      summary: 查询所有的订单，统计不同类型的商品不同时间段的销售总数
 *      parameters:
 *      - name: name
 *        in: query
 *        description: 商品类型
 *        required: false
 *      - name: arr
 *        in: query
 *        description: 该类型商品集合
 *        required: false
 *      responses:
 *        200:
 *          description: 操作成功
 *        401:
 *          description: 权限不足
 * */
// 3.查询所有的订单，统计不同类型的商品不同时间段的销售总数   snaps
router.get('/allorderByTime', async function (req, res, next) {
    // 查询所有的商品类型
    let arrType = await typesService.findAll();
    // 存所有的商品类型
    let typeArr = [];
    // 存通过订单id查询到的具体某个商品的快照信息
    let commityArr = [];
    // arrType是异步获取
    if (arrType) {
        // 存所有类型
        typeArr = arrType.map(item => {
            return {
                name: item.typeName,
                arr: []
            }
        });
    }
    // 拿到所有的订单集合
    let arrOrder = await analysisService.findAllOrder();
    if (arrOrder) {
        // 查询不同内型商品数量并累加
        for (let i = 0; i < arrOrder.length; i++) {
            // 通过订单id查询订单相关的商品信息
            commityArr = await snapService.findByOrderId(arrOrder[i]._id);
            if (commityArr.length > 0) {
                // 一个订单有多个商品
                for (let m = 0; m < commityArr.length; m++) {
                    for (let j = 0; j < typeArr.length; j++) {
                        if (commityArr[m].types === typeArr[j]['name']) {
                            typeArr[j]['arr'].push(
                                {
                                    time: arrOrder[i].time,
                                    commodity: commityArr[m]
                                });
                        }
                    }
                }
            }
        }
        // 返回数据
        res.send({
            data: typeArr
        });
    }
});
/**
 * @swagger
 * /analysis/allcommiditywithtime:
 *    get:
 *      tags:
 *      - analysis
 *      summary: 查询所有的订单，统计商品的购买时间和其他相关信息
 *      parameters:
 *      - name: time
 *        in: query
 *        description: 商品类型
 *        required: false
 *      - name: commodity
 *        in: query
 *        description: 该商品信息
 *        required: false
 *      responses:
 *        200:
 *          description: 操作成功
 *        401:
 *          description: 权限不足
 * */
// 4.查询所有的订单，统计不同类型的商品不同时间段的销售总数   snaps
router.get('/allcommiditywithtime', async function (req, res, next) {
    // 存所有的商品
    let typeArr = [];
    // 存通过订单id查询到的具体某个商品的快照信息
    let commityArr = [];
    // 拿到所有的订单集合
    let arrOrder = await analysisService.findAllOrder();
    if (arrOrder) {
        // 查询不同内型商品数量并累加
        for (let i = 0; i < arrOrder.length; i++) {
            // 通过订单id查询订单相关的商品信息
            commityArr = await snapService.findByOrderId(arrOrder[i]._id);
            if (commityArr.length > 0) {
                // 一个订单有多个商品
                for (let m = 0; m < commityArr.length; m++) {
                    typeArr.push(
                        {
                            time: arrOrder[i].time,
                            commodity: commityArr[m]
                        });
                }
            }
        }
        // 返回数据
        res.send({
            data: typeArr
        });
    }
});
/**
 * @swagger
 * /analysis/{id}:
 *    get:
 *      summary: 根据id查询某个商品的销量
 *      tags:
 *       - analysis
 *      parameters:
 *      - name: id
 *        in: path
 *        description: 商品id
 *        required: true
 *      responses:
 *        200:
 *          description: 操作成功
 *        401:
 *          description: 权限不足
 * */
//5. 通过商品id查询该商品的销量
router.get("/:id", async function (req, res) {
    let { id } = req.params;
    let searchObj = {};
    if (id) {
        searchObj['shopId'] = id;
    }
    // 某个商品初始销售量 
    let sale = 0;
    // 查询所有的商品快照集合表中该商品的购买信息
    let arrOld = await snapService.findSnap(searchObj, { current: 1, pageSize: 500 });
    // 遍历该商品所有的订单信息进行销量进行累加
    arrOld.rows.map(item => sale += parseInt(item.sale * parseInt(item.price)));
    res.send({ sale });
})




module.exports = router;